package javaer.starter.base.service;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import javaer.starter.base.dao.ModuleDAO;
import javaer.starter.base.dao.ModuleDependencyDAO;
import javaer.starter.base.domain.dto.ModuleDTO;
import javaer.starter.base.domain.dto.ModuleDependencyDTO;
import javaer.starter.base.domain.model.ModuleDependency;
import javaer.starter.base.domain.model.ModuleModel;
import javaer.starter.constant.RequiredEnum;
import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

@Service
public class ModuleService extends ServiceImpl<ModuleDAO, ModuleModel> {

    @Resource
    private ModuleDAO moduleDAO;

    @Resource
    private ModuleDependencyDAO moduleDependencyDAO;

    public ModuleModel findByTypeIdAndModuleId(String typeId, String moduleId) {
        return moduleDAO.selectOne(new QueryWrapper<ModuleModel>()
                .lambda()
                .eq(ModuleModel::getTypeId, typeId)
                .eq(ModuleModel::getModuleId, moduleId)
        );
    }

    public Set<ModuleDTO> findByTypeId(String typeId) {
        return findByTypeIdAndModuleIds(typeId, null);
    }

    public Set<ModuleDTO> findByTypeIdAndModuleIds(String typeId, Set<String> moduleIds) {
        List<ModuleModel> moduleModels = moduleDAO.selectList(new QueryWrapper<ModuleModel>()
                .lambda()
                .eq(ModuleModel::getTypeId, typeId)
                .in(!ObjectUtils.isEmpty(moduleIds), ModuleModel::getModuleId, moduleIds)
        );

        if (CollectionUtils.isNotEmpty(moduleModels)) {
            Set<ModuleDTO> result = moduleModels.stream().map(module -> {
                ModuleDTO moduleDTO = new ModuleDTO();
                BeanUtils.copyProperties(module, moduleDTO);
                moduleDTO.setRequired(RequiredEnum.YES.getRequired().equals(module.getRequired()));
                moduleDTO.setStarter(RequiredEnum.YES.getRequired().equals(module.getStarter()));
                return moduleDTO;
            }).collect(Collectors.toSet());
            return result;
        }
        return null;
    }

    public List<ModuleDependencyDTO> findModuleDependencyByTypeIdAndModuleIdAndDepType(String typeId, String moduleId, Integer depType) {

        List<ModuleDependency> moduleDependencies = moduleDependencyDAO.selectList(new QueryWrapper<ModuleDependency>()
                .lambda()
                .eq(ModuleDependency::getTypeId, typeId)
                .eq(ModuleDependency::getModuleId, moduleId)
                .eq(ModuleDependency::getDepType, depType)
        );
        if (CollectionUtils.isNotEmpty(moduleDependencies)) {
            List<ModuleDependencyDTO> result = moduleDependencies.stream().map(md -> {
                ModuleDependencyDTO moduleDependencyDTO = new ModuleDependencyDTO();
                BeanUtils.copyProperties(md, moduleDependencyDTO);
                return moduleDependencyDTO;
            }).collect(Collectors.toList());
            return result;
        }
        return null;
    }
}
